python_base={
       "IDE":{
               "IDLE":{
                   "操作":"100（90）",
                   "意义":"100（80）"
               },
               "jupyter notebook":{
                   "操作": "100(80)",
                   "拓展插件": "100(75)"
               },
               "pycharm":{
                   "操作": "100(85)",
                   "界面选项": "100(70)"
               }
       },
    "Anaconda": {
        "安装、配置与使用": "100(80)",
        "意义": "100(80)"
    },
    "标准库": {
        "分类": "100(80)",
        "使用": "100(75)"
    },
    "流程控制语句": {
        "条件语句": {
            "if 语句": "100(85)",
            "else 语句": "100(80)",
            "elif 语句": "100(80)"
            # if xxx:
            # elif xxx:
            # else:
        },
        "循环语句": {
            "while循环": "100(75)",
            #while 判断条件(condition)：
            #   执行语句(statements)……
            "for循环": {
                "迭代列表": "100(95)",
                # for i in[1,2,3]:
                #       priint(i)
                "迭代字符串":"100(95)",
                # for ch in"Hi!":
                #       print(ch)
                "迭代指定的次数": "100(95)"
                # for num in range(5):
                #       print('head first rocks!')
            }
        },
        "循环嵌套": "100(75)"
        #i = 2
        #while(i < 100):
       #   j = 2
       #  while(j <= (i/j)):
       #     if not(i%j): break
       #     j = j + 1
       #  if (j > i/j) : print i, " 是素数"
       #  i = i + 1

      #print "Good bye!"
    },
    "变量": {
        "赋值": "100(80)",
        "数据类型": {
            "字符串": {
                "字符串连接":"100(80)",
                # var1 = 'Hello World!'

                # print "输出 :- ", var1[:6] + 'Runoob!'
                # 输出 :-  Hello Runoob!
                "json转义": "100(80)",
                "占位符与 format() ": "100(85)",
                "''.join()": "100(80)", # 拼接
                "str.split（）":"100(85)", # 拆分
                "str.count()":"100(90)", # 计算次数
                "str.isdigit":"100(85)", #如果字符串只包含数字则返回 True，否则返回 False。
            },
            "数字": {
                "生成随机数字": "100(100)",
                # >>> wait_time = ramdom.randint(1,60)
                # >>> wait_time
                # 26
            }
        }
    },
    "内置数据结构": {
        "列表": {
            "操作": {
                "切片": "100(80)", # list[start,end,step]
                "列表函数":"100(80)",
                # len(list) -> 列表元素个数
                # max(list) -> 返回列表元素最大值
                # min(list) -> 返回列表元素最小值
                # list(seq) -> 将元组转换为列表
                "列表方法":"100(80)"
                # 1 list.append(obj)
                # 在列表末尾添加新的对象
                # 2	list.count(obj)
                # 统计某个元素在列表中出现的次数
                # 3	list.extend(seq)
                # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
                # 4	list.index(obj)
                # 从列表中找出某个值第一个匹配项的索引位置
                # 5	list.insert(index, obj)
                # 将对象插入列表
                # 6	list.pop([index=-1])
                # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
                # 7	list.remove(obj)
                # 移除列表中某个值的第一个匹配项
                # 8	list.reverse()
                # 反向列表中元素
                # 9	list.sort(cmp=None, key=None, reverse=False)
                # 对原列表进行排序
            },
        "元组":{
            "操作":{
                "元组内置函数":"100(75)"
                # 1	cmp(tuple1, tuple2)
                # 比较两个元组元素。
                # 2	len(tuple)
                # 计算元组元素个数。
                # 3	max(tuple)
                # 返回元组中元素最大值。
                # 4	min(tuple)
                # 返回元组中元素最小值。
                # 5	tuple(seq)
                # 将列表转换为元组。
            }
        },

        "字典": {
            "操作": {
                "访问字典里的值":"100(100)",
                # dict = {'Name': 'tll'}
                # dict['Name']
                # tll
                "修改字典":"100(100)",
                # dict1 = {'Name': 'tll'}
                # dict1['Name'] = lily
                # dict1
                # lily
                "删除字典元素":"100(100)",
                # dict = {'Name': 'tll'}
                # del dict
                # dict={}
                "字典键的特性":"100(80)",
                # 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
                # 2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
                "字典内置函数":"100(90)",
                # 1	cmp(dict1, dict2)
                # 比较两个字典元素。
                # 2	len(dict)
                # 计算字典元素个数，即键的总数。
                # 3	str(dict)
                # 输出字典可打印的字符串表示。
                # 4	type(variable)
                # 返回输入的变量类型，如果变量是字典就返回字典类型。
                "字典内置方法":"100(90)"
                # 1	dict.clear()
                # 删除字典内所有元素
                # 2	dict.copy()
                # 返回一个字典的浅复制
                # 3	dict.fromkeys(seq[, val])
                # 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
                # 4	dict.get(key, default=None)
                # 返回指定键的值，如果值不在字典中返回default值
                # 5	dict.has_key(key)
                # 如果键在字典dict里返回true，否则返回false
                # 6	dict.items()
                # 以列表返回可遍历的(键, 值) 元组数组
                # 7	dict.keys()
                # 以列表返回一个字典所有的键
                # 8	dict.setdefault(key, default=None)
                # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
                # 9	dict.update(dict2)
                # 把字典dict2的键/值对更新到dict里
                # 10 dict.values()
                # 以列表返回字典中的所有值
                # 11 pop(key[,default])
                # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
                # 12 popitem()
                # 返回并删除字典中的最后一对键和值。


            },
        },

        "集合":{
            "集合的基本操作":{
                "添加元素":"100（85）", # s.update( x )
                "移除元素":"100（85）",  # s.remove( x ）
                "计算集合元素个数":"100（85）",  # len(s)
                "清空集合":"100（85）", # s.clear()
                "判断元素是否在集合中存在":"100（80）", # x in s
                "集合内置方法完整列表":"100（80）"
                # add()	为集合添加元素
                # clear()	移除集合中的所有元素
                # copy()	拷贝一个集合
                # difference()	返回多个集合的差集
                # difference_update()	移除集合中的元素，该元素在指定的集合也存在。
                # discard()	删除集合中指定的元素
                # intersection()	返回集合的交集
                # intersection_update()	返回集合的交集。
                # isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
                # issubset()	判断指定集合是否为该方法参数集合的子集。
                # issuperset()	判断该方法的参数集合是否为指定集合的子集
                # pop()	随机移除元素
                # remove()	移除指定元素
                # symmetric_difference()	返回两个集合中不重复的元素集合。
                # symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
                # union()	返回两个集合的并集
                # update()	给集合添加元素
            }
        },

    "函数": {
        "定义函数": "100(80)",
        # def 函数名（参数列表）:
        #     函数体
        "函数调用": "100(75)", # 如调用printme()函数
        "参数传递": "100(70)",
        "参数":{
            "必需参数":"100(70)", # 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
            "关键字参数":"100(75)",
            "默认参数":"100(75)", # 调用函数时，如果没有传递参数，则会使用默认参数。
            "不定长参数":"100(50)"
        },
        "函数*args":"100(75)",
        "函数**kwargs":"100(75)"

    }

}



